/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package vengadores;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import javax.microedition.io.Connector;
import javax.microedition.io.file.FileConnection;

/**
 * Clase que se encarga del manejo de los archivos y de la lectura y escritura de los mismos
 * @author Jorge de Jesús Tinoco Huesca 1165318
 * @author Arturo Ayala Tello 1164742
 * @author Felipe Donato Arrazola Gómez 1165547
 */
public class AdminArchivos {

    private String datos;//String que guarda los datos leidos o los datos a escribir
    private String[] nombres;//Arreglo de String que almacena los nombres de Los Mejores
    private int [] scores;//Arreglo de enteros que guarda los puntajes de Los Mejores
    private int[] datosContinuar;//Arreglo de enteros que guarda los datos para continuar el juego
    private int scoreTemp; //Puntaje temporal para transiciones entre pantallas
    private boolean estaEnShooter; //Booleano que guarda si está en shooter o no
    private static final int MAX_ESCRITOS = 3;//Máximo de elemtos a guardar en Los Mejores

    /**
     * Constructor que lee los archivos guardados en el celular, si no existen dichos archivos, los crea y guarda
     * datos en ellos
     * @throws IllegalAccessException si no existe una tarjeta de memoria instalada en el celular
     */
    public AdminArchivos() throws IllegalAccessException{
        datos = "";
        nombres = new String[MAX_ESCRITOS];
        scores = new int[MAX_ESCRITOS];
        datosContinuar = new int[6];
        try {
            FileConnection fc = (FileConnection) Connector.open("file:///e:/",Connector.READ_WRITE);
            if(!fc.exists()){
                throw new IllegalAccessException();
            }
            fc.close();
            fc = (FileConnection) Connector.open("file:///e:/VA/",Connector.READ_WRITE);
            if(!fc.exists()){
                System.out.println("creando directorio");
                fc.mkdir();
            }
            fc.close();
            fc = (FileConnection) Connector.open("file:///e:/VA/guardadoVA.txt",Connector.READ_WRITE);
            if(!fc.exists()){
                System.out.println("creando archivo");
                fc.create();
                for (int i = 0; i < datosContinuar.length; i++){
                    datosContinuar[i] = 0;
                    datos += datosContinuar[i] + "\t";                    
                }
                estaEnShooter = false;
                datos += 0+"\t";
                OutputStreamWriter salida = new OutputStreamWriter(fc.openDataOutputStream());
                salida.write(datos);
                salida.close();
                fc.close();
            }else{
                InputStream entrada = fc.openInputStream();
                byte[] bytes = new byte[512];
                int leidos = entrada.read(bytes);
                datos = new String(bytes, 0, leidos);
                String temp = "";
                int indiceArreglo = 0;
                for (int i = 0; i < datos.length(); i++){
                    if((datos.charAt(i) != '\t')){
                        temp += datos.charAt(i);
                    }else{
                        int numero = Integer.parseInt(temp);
                        if (indiceArreglo >= datosContinuar.length){
                            if(numero == 0){
                                estaEnShooter = false;
                            }else{
                                estaEnShooter = true;
                            }
                        }else{
                            datosContinuar[indiceArreglo] = numero;
                            indiceArreglo++;
                            temp = "";
                        }
                    }
                }
                fc.close();
                entrada.close();
            }
            datos = "";
            fc = (FileConnection) Connector.open("file:///e:/VA/mejores.txt",Connector.READ_WRITE);
            if (!fc.exists()){
                System.out.println("creando archivo");
                fc.create();
                for (int i = 0 ; i < MAX_ESCRITOS; i++){
                    nombres[i] = "JFA";
                    scores[i] = (MAX_ESCRITOS - i)*100;
                    datos += nombres[i]+"\t"+scores[i]+"\n";
                }
                System.out.println(datos);
                OutputStreamWriter salida = new OutputStreamWriter(fc.openDataOutputStream());
                salida.write(datos);
                salida.close();
                fc.close();
            }else{
                InputStream entrada = fc.openInputStream();
                byte[] bytes = new byte[512];
                int leidos = entrada.read(bytes);
                datos = new String(bytes, 0, leidos);
                System.out.println(datos);
                String nombreLeido = "";
                String numeroLeido = "";
                int numero = 0;
                int indice = 0;
                char caracterLeido;
                for (int i = 0; i < datos.length(); i++){
                    caracterLeido = datos.charAt(i);
                    if (caracterLeido != '\t' && caracterLeido != '\n'){
                        if (Character.isDigit(caracterLeido)){
                            numeroLeido += caracterLeido;
                            System.out.println("es un numero "+numeroLeido);
                        }else{
                            nombreLeido += caracterLeido;
                            System.out.println("es un caracter "+nombreLeido);
                        }
                    }
                    if (caracterLeido == '\n'){
                        numero = Integer.parseInt(numeroLeido);
                        System.out.println("numero procesado "+numero);
                        System.out.println("nombre procesado "+nombreLeido);
                        nombres[indice] = nombreLeido;
                        scores[indice] = numero;
                        indice++;
                        nombreLeido = "";
                        numeroLeido = "";
                    }
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Método que guarda un juego, los parámetros son datos necesarios para continuar el juego
     * @param nivel es el nivel donde se quedó el personaje
     * @param sexo es el genero del heroe
     * @param xPersonaje es la posición en x donde se quedó en el último punto de control
     * @param yPersonaje es la posición en y donde se quedó en el último punto de control
     * @param ptoControl es el punto de control donde se quedó
     * @param score es el puntaje que tenía registrado en ese momento
     * @param estaShooter si está en shooter o no
     */
    public void guardarJuego(int nivel, int sexo, int xPersonaje, int yPersonaje, int ptoControl, int score, boolean estaShooter){
        datosContinuar[0] = nivel;
        datosContinuar[1] = sexo;
        datosContinuar[2] = xPersonaje;
        datosContinuar[3] = yPersonaje;
        datosContinuar[4] = ptoControl;
        datosContinuar[5] = score;
        estaEnShooter = estaShooter;
    }

    /**
     * Método que guarda el puntaje obtenido y el nombre de la persona que lo generó
     * @param nombre es el nombre de la persona que generó el puntaje
     * @param score es el puntaje obtenido
     */
    public void guardarScore(String nombre, int score){
        for (int i = 0; i < scores.length; i++){
            if (score >= scores[i]){
                for (int j = scores.length-1; j > i; j--){
                    scores[j] = scores[j-1];
                    nombres[j] = nombres[j-1];
                }
                scores[i] = score;
                nombres[i] = nombre;
                break;
            }
        }
    }

    /**
     * Método que analiza el puntaje mandado y si es candidato para ser guardado lo almacena
     * @param score es el puntaje generado por alguien
     * @return si el puntaje que se le mandó como parámetro es candidato para ser guardado
     */
    public boolean analizar(int score){
        for (int i = 0; i < scores.length; i++){
            if (score >= scores[i]){
                System.out.println("guardando puntaje");
                scoreTemp = score;
                return true;
            }
        }
        return false;
    }

    /**
     * Método que regresa el puntaje temporal que se guardo al analizar el archivo
     * @return el puntaje temporal
     */
    public int getScoreTemp(){
        return scoreTemp;
    }

    /**
     * Método que regresa el arreglo de String de los nombres de Los Mejores
     * @return un arreglo de Strings que contiene nombres de personas
     */
    public String[] getNombres(){
        return nombres;
    }

    /**
     * Método que regresa el arreglo de enteros donde se almacenan los punajes de Los Mejores
     * @return un arreglo de enteros que contienen los puntajes guardados
     */
    public int[] getScores(){
        return scores;
    }

    /**
     * Método que regresa la posición en x donde se quedó el personaje en el último punto de control
     * @return la posición del personaje en x
     */
    public int getXPersonaje() {
        return datosContinuar[2];
    }

    /**
     * Método que regresa la posición en y donde se quedo el personaje en el último punto de control
     * @return la posición del personaje en y
     */
    public int getYPersonaje(){
        return datosContinuar[3];
    }
    /**
     * Método que regresa el punto de control donde se quedó el personaje
     * @return un entero que representa el punto de control guardado
     */
    public int getPuntoControl(){
        return datosContinuar[4];
    }
    /**
     * Método que elimina todas las referencias de la clase
     */
    public void terminar(){
         try {
             datos = "";
            FileConnection fc = (FileConnection) Connector.open("file:///e:/VA/guardadoVA.txt",Connector.READ_WRITE);
            if(fc.exists()){
                fc.delete();
            }
            fc.create();
            for (int i = 0; i < datosContinuar.length; i++){
                datos += datosContinuar[i]+"\t";
            }
            if(estaEnShooter){
                datos += 1;
            }else{
                datos += 0;
            }
            datos += "\t";
             System.out.println(datos);
            OutputStreamWriter salida = new OutputStreamWriter(fc.openDataOutputStream());
            salida.write(datos);
            salida.close();
            fc.close();
            datos = "";
            fc = (FileConnection) Connector.open("file:///e:/VA/mejores.txt",Connector.READ_WRITE);
            if (!fc.exists()){
                fc.create();
            }
            for (int i = 0 ; i < MAX_ESCRITOS; i++){
                datos += nombres[i]+"\t"+scores[i]+"\n";
            }
            salida = new OutputStreamWriter(fc.openDataOutputStream());
            salida.write(datos);
            salida.close();
            fc.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        datos = null;
        for(int i = 0; i < nombres.length; i++){
            nombres[i] = null;
        }
        nombres = null;

    }

    /**
     * Método que recupera el nivel guardado en el archivo
     * @return el entero que representa el nivel
     */
    public int getNivel() {
        return datosContinuar[0];
    }
    /**
     * Método que regresa el entero que representa el genero del personaje
     * @return el genero del personaje
     */
    public int getSexo() {
        return datosContinuar[1];
    }
    /**
     * Método que regresa el puntaje almacenado en el archivo
     * @return un entero que representa el puntaje
     */
    public int getScore() {
        return datosContinuar[5];
    }
    /**
     * Método que regresa si está en Shooter o no a la hora de almacenar el archivo
     * @return un booleano que indica si está en shooter o no
     */
    public boolean getEdoShooter() {
        return estaEnShooter;
    }



}
